/********************************************************************************
 * 配置说明：
 *
 * 1. 外部模板URL配置：
 *    - 在 fetchTemplatesFromExternalUrl 函数中，将示例URL替换为您的实际URL
 *    - 推荐使用：Gitee、GitHub Gist、码云或其他支持直接访问JSON文件的公共服务
 *    - 示例：https://gitee.com/yourusername/repo/raw/main/hotel-templates.json
 *    - 示例：https://gist.githubusercontent.com/yourusername/gist-id/raw/hotel-templates.json
 *
 * 2. JSON数据格式要求：
 *    {
 *      "酒店名称1": "模板文本，支持变量如${hotelName}、${roomNum}等",
 *      "酒店名称2": "另一个模板文本",
 *      // 更多酒店模板...
 *    }
 *
 *    注意：服务器返回的数据可以是：
 *    - 直接的JSON文本
 *    - Base64编码的JSON文本（支持中文内容，脚本会自动解码）
 *
 * 3. 可用变量：
 *    - ${hotelName}: 酒店名称
 *    - ${userName}: 入住人姓名
 *    - ${roomType}: 房型
 *    - ${mealType}: 餐型
 *    - ${startDate}: 入住日期
 *    - ${endDate}: 离店日期
 *    - ${roomNum}: 房间数
 *    - ${nightNum}: 晚数
 *    - ${channel}: 渠道
 *
 * 4. 本地降级方案：
 *    - 当外部URL无法访问或加载失败时，将自动使用内置的默认模板
 *    - 默认模板可在 getDefaultTemplates 函数中查看和修改
 *
 * 5. 调试信息：
 *    - 按F12打开开发者工具，在Console标签页中查看详细日志
 *    - 包括模板加载状态、处理进度和可能的错误信息
 *
 * 6. 使用方法：
 *    - 安装脚本后，打开携程酒店订单页面
 *    - 页面会自动加载模板并处理订单行
 *    - 双击生成的备注可复制到剪贴板
 ********************************************************************************/

// 酒店预订信息模板管理和格式化工具

// 外部模板URL - 用户可修改此URL以指向自定义的模板数据源
const TEMPLATES_URL = 'https://gitee.com/api/v5/repos/fuckv587/cf/contents/mt-dls/hotel.json?ref=master'; // Gitee API示例

// 用于存储酒店模板的全局变量
let myMap = new Map();
let intervalID = null;

/**
 * 从外部URL获取酒店模板数据
 * @returns {Promise<Map<string, string>>} 包含各酒店预订信息模板的Map
 */
async function fetchTemplatesFromExternalUrl() {
    try {
        console.log('开始从外部URL获取模板数据...');

        /**********************************************************
         * 重要配置点！请修改以下URL为您的实际模板文件地址
         *
         * 推荐的外部数据源选项：
         * 1. Gitee：https://gitee.com/yourusername/repo/raw/main/hotel-templates.json
         * 2. GitHub Gist：https://gist.githubusercontent.com/yourusername/gist-id/raw/hotel-templates.json
         * 3. 其他支持CORS的JSON服务
         *
         * 请确保：
         * - URL可以公开访问
         * - 返回有效的JSON格式
         * - 服务器支持跨域访问(CORS)
         *
         * 如遇加载失败，脚本会自动使用内置默认模板
         **********************************************************/
        // 请修改这里的URL ↓↓↓
        const response = await fetch(TEMPLATES_URL, {
            timeout: 10000, // 设置10秒超时
            headers: {
                'Accept': 'application/json'
            }
        });

        if (!response.ok) {
            const errorMsg = `HTTP错误! 状态: ${response.status} ${response.statusText}`;
            console.error(errorMsg);
            showMessage(`模板加载失败: ${response.status}，使用默认模板`);
            throw new Error(errorMsg);
        }

        console.log('HTTP请求成功，开始处理响应数据...');

        // 首先获取原始响应文本
        const responseText = await response.text();
        console.log('获取到响应文本，长度:', responseText.length);

        let data;
            // 尝试base64解码方式（支持中文内容）
            try {
                // 使用decodeURIComponent(escape(atob()))解码base64编码的中文内容
                const responseObj = JSON.parse(responseText);
                const decodedContent = decodeURIComponent(escape(atob(responseObj.content)));
                console.log('base64解码成功，开始解析JSON...');
                data = JSON.parse(decodedContent);
            } catch (decodeError) {
                const errorMsg = '数据解码和解析失败，格式不正确';
                console.error(errorMsg, '解码错误:', decodeError.message);
                showMessage('模板数据解码失败，使用默认模板');
                throw new Error(errorMsg);
            }

        // 检查数据格式是否正确
        if (!data || typeof data !== 'object' || Array.isArray(data)) {
            const errorMsg = '获取的模板数据格式无效，应为JSON对象';
            console.error(errorMsg, '数据类型:', typeof data);
            showMessage('模板数据格式错误，使用默认模板');
            throw new Error(errorMsg);
        }

        console.log('数据解析成功，包含', Object.keys(data).length, '个模板项');

        const templates = new Map();
        const hotelNames = Object.keys(data);

        // 验证数据内容并转换为Map
        if (hotelNames.length === 0) {
            console.warn('获取的模板数据为空，使用默认模板');
            showMessage('模板数据为空，使用默认模板');
            return getDefaultTemplates();
        }

        hotelNames.forEach(hotelName => {
            const template = data[hotelName];
            // 验证模板格式
            if (typeof template === 'string' && template.includes('${')) {
                templates.set(hotelName, template);
            } else {
                console.warn(`忽略无效模板: ${hotelName}`);
            }
        });

        console.log(`成功获取并解析模板数据，共${templates.size}个有效模板`);

        // 如果有效模板数量很少，显示警告
        if (templates.size < 5) {
            console.warn(`模板数量较少: ${templates.size}个，可能数据不完整`);
            showMessage(`成功加载${templates.size}个模板`);
        } else {
            showMessage(`模板加载成功，共${templates.size}个`);
        }

        return templates;
    } catch (error) {
        console.error('从外部URL获取模板失败:', error);
        // 分类错误类型，提供更具体的错误信息
        if (error.name === 'AbortError' || error.message.includes('timeout')) {
            showMessage('模板加载超时，请检查网络连接');
        } else if (error.message.includes('Failed to fetch')) {
            showMessage('无法连接到模板服务器，请检查URL');
        } else {
            showMessage('模板加载失败，使用默认模板');
        }
        // 返回默认模板作为降级方案
        return getDefaultTemplates();
    }
}

/**
 * 获取默认酒店模板（降级方案）
 * @returns {Map<string, string>} 默认酒店模板Map
 */
function getDefaultTemplates() {
    console.log('使用默认模板作为降级方案');
    const templates = new Map();

    // 设置默认键值对（保留部分常用模板作为降级方案）
    templates.set('常州环球港邮轮酒店', '${userName}  ${roomType}-${mealType} ${startDate}  ${roomNum}${nightNum}  晨风旅行社 房价0   房费预付，杂费自理，房价保密');
    templates.set('常州远洲酒店', '${userName}  ${roomType} ${mealType}  ${startDate}  ${roomNum}${nightNum}  ');
    templates.set('常州宝丽格大酒店', '${userName}  ${roomType} ${mealType}  ${startDate}  ${roomNum}${nightNum}  0');

    return templates;
}

/**
 * 初始化酒店模板Map对象
 * @returns {Promise<Map<string, string>>} 包含各酒店预订信息模板的Map
 */
async function initializeHotelTemplates() {
    try {
        console.log('初始化酒店模板...');

        // 记录开始时间用于性能监控
        const startTime = Date.now();

        // 从外部URL获取模板
        const templates = await fetchTemplatesFromExternalUrl();

        // 检查返回的模板
        if (!templates || !(templates instanceof Map)) {
            console.error('获取的模板不是有效的Map对象');
            showMessage('模板类型错误，使用默认模板');
            const defaultTemplates = getDefaultTemplates();
            myMap = defaultTemplates;
            return defaultTemplates;
        }

        if (templates.size === 0) {
            console.warn('未获取到有效模板，使用默认模板');
            showMessage('未找到有效模板，使用默认模板');
            const defaultTemplates = getDefaultTemplates();
            myMap = defaultTemplates;
            return defaultTemplates;
        }

        // 更新全局myMap变量
        myMap = templates;

        // 记录初始化完成和耗时
        const endTime = Date.now();
        console.log(`模板初始化完成，耗时: ${endTime - startTime}ms, 共${templates.size}个模板`);

        // 记录部分模板名称用于调试
        const templateNames = Array.from(templates.keys()).slice(0, 5).join(', ');
        if (templates.size > 5) {
            console.log(`部分模板名称: ${templateNames}...等${templates.size}个`);
        } else {
            console.log(`模板名称: ${templateNames}`);
        }

        return templates;
    } catch (error) {
        console.error('模板初始化异常:', error);
        showMessage('初始化模板时发生异常，使用默认模板');
        // 确保返回一个有效的Map对象
        const defaultTemplates = getDefaultTemplates();
        myMap = defaultTemplates;
        console.log(`使用默认模板，共${defaultTemplates.size}个`);
        return defaultTemplates;
    }
}

/**
 * 创建自定义提示框
 * @returns {HTMLElement} 创建的提示框DOM元素
 */
function createMessageBox() {
    const newDiv = document.createElement("div");
    newDiv.id = "myMessageBox";

    // 设置样式
    Object.assign(newDiv.style, {
        position: "fixed",
        top: "20px",
        left: "50%",
        transform: "translateX(-50%)",
        backgroundColor: "#D3A053FF",
        color: "white",
        padding: "10px 20px",
        borderRadius: "5px",
        fontSize: "16px",
        display: "none",
        zIndex: "9999",
        fontWeight: "bold",
        boxShadow: "0 2px 10px rgba(0, 0, 0, 0.3)"
    });

    newDiv.textContent = "提示消息";
    document.body.appendChild(newDiv);
    return newDiv;
}

/**
 * 显示提示消息
 * @param {string} message - 要显示的消息内容
 * @param {number} duration - 消息显示持续时间（毫秒），默认20
 */
function showMessage(message, duration = 2000) {
    const messageBox = document.getElementById("myMessageBox");
    if (messageBox) {
        messageBox.textContent = message;
        messageBox.style.display = "block";

        // 使用setTimeout代替jQuery的fadeIn/fadeOut，减少依赖
        setTimeout(() => {
            messageBox.style.display = "none";
        }, duration);
    }
}

/**
 * 复制内容到剪贴板
 * @param {string} content - 要复制的内容
 * @returns {Promise<void>}
 */
async function copyToClipboard(content) {
    try {
        // 优先使用现代的Clipboard API
        await navigator.clipboard.writeText(content);
        showMessage("复制成功");
    } catch (error) {
        // 降级方案：使用传统的execCommand方法
        try {
            const textArea = document.createElement('textarea');
            textArea.value = content;
            textArea.style.position = 'fixed';
            textArea.style.left = '-999999px';
            textArea.style.top = '-999999px';
            document.body.appendChild(textArea);
            textArea.focus();
            textArea.select();
            document.execCommand('copy');
            document.body.removeChild(textArea);
            showMessage("复制成功");
        } catch (fallbackError) {
            console.error('复制失败:', fallbackError);
            alert('复制失败，请手动复制');
        }
    }
}

/**
 * 从模板生成格式化的预订信息
 * @param {string} template - 模板字符串
 * @param {Object} data - 包含变量值的对象
 * @returns {string} 格式化后的字符串
 */
function formatTemplate(template, data) {
    // 使用正则表达式统一替换所有变量，比多次调用replace更高效
    return template.replace(/\${([^}]*)}/g, (match, key) => {
        return data[key] || '';
    });
}

/**
 * 提取日期信息
 * @param {string} inputString - 包含日期信息的字符串
 * @returns {Array<string>} [startDate, endDate, nights] 如果提取成功，否则返回空数组
 */
function getDate(inputString) {
    try {
        // 使用正则表达式匹配日期和晚数
        const regex = /(\d{4}-\d{2}-\d{2})至(\d{4}-\d{2}-\d{2})\((\d+)晚\)/;
        const match = inputString.match(regex);

        if (match) {
            return [match[1], match[2], match[3]];
        }
        return [];
    } catch (error) {
        console.error('日期提取错误:', error);
        return [];
    }
}

/**
 * 提取酒店名称
 * @param {string} inputString - 包含酒店名称的字符串
 * @returns {string|null} 酒店名称，如果提取失败返回null
 */
function getHotelName(inputString) {
    try {
        // 使用正则表达式匹配 `/` 后面的部分
        const regex = /\/(.+)$/;
        const match = inputString.match(regex);
        return match ? match[1] : null;
    } catch (error) {
        console.error('酒店名称提取错误:', error);
        return null;
    }
}

/**
 * 提取房型信息
 * @param {string} inputString - 包含房型信息的字符串
 * @returns {string} 房型信息
 */
function getRoomType(inputString) {
    try {
        const roomRegex = /(.+?[房|间|屋][ABCDE]?)/;
        const roomMatch = inputString.match(roomRegex);
        return roomMatch ? roomMatch[1] : (inputString.split('<')[0] || '');
    } catch (error) {
        console.error('房型提取错误:', error);
        return '';
    }
}

/**
 * 提取餐型信息
 * @param {string} inputString - 包含餐型信息的字符串
 * @returns {string} 餐型信息
 */
function getMealType(inputString) {
    try {
        const mealRegex = /<([^>]*早[^>]*)>/g;
        const mealMatches = [];
        let mealMatch;

        while ((mealMatch = mealRegex.exec(inputString)) !== null) {
            mealMatches.push(mealMatch[1]);
        }

        return mealMatches.join(' ') || '';
    } catch (error) {
        console.error('餐型提取错误:', error);
        return '';
    }
}

/**
 * 提取晚数信息
 * @param {string} inputString - 包含晚数信息的字符串
 * @returns {string} 晚数信息
 */
function getNightNum(inputString) {
    try {
        const regex = /\((.*?)\)/;
        const match = inputString.match(regex);
        return match ? match[1] : '';
    } catch (error) {
        console.error('晚数提取错误:', error);
        return '';
    }
}

/**
 * 提取房间数量信息
 * @param {string} inputString - 包含房间数量信息的字符串
 * @returns {string} 房间数量信息
 */
function getRoomNum(inputString) {
    try {
        const regex = /\((.*?)\)/;
        const match = inputString.match(regex);
        return match ? match[1] : '';
    } catch (error) {
        console.error('房间数量提取错误:', error);
        return '';
    }
}

/**
 * 提取渠道信息
 * @param {string} channelStr - 包含渠道信息的字符串
 * @returns {string} 渠道名称（携程、艺龙或去哪儿）
 */
function getChannel(channelStr) {
    if (channelStr.indexOf('艺龙') > -1) {
        return '艺龙';
    } else if (channelStr.indexOf('去哪儿') > -1) {
        return '去哪儿';
    }
    return '携程';
}

/**
 * 处理HTML内容，转换为纯文本并保留换行
 * @param {string} htmlContent - HTML内容
 * @returns {string} 处理后的纯文本
 */
function processHtmlContent(htmlContent) {
    try {
        // 替换 <br> 为换行符
        let tempHtml = htmlContent.replace(/<br\s*\/?>/gi, '\n');
        // 替换 &nbsp; 为空格
        tempHtml = tempHtml.replace(/&nbsp;/g, ' ');

        // 使用DOMParser解码HTML实体
        const decodedContent = new DOMParser()
            .parseFromString(tempHtml, 'text/html')
            .documentElement.textContent;

        return decodedContent;
    } catch (error) {
        console.error('HTML内容处理错误:', error);
        return htmlContent;
    }
}

/**
 * 处理酒店行并添加预订信息
 * @param {jQuery} row - 酒店行jQuery对象
 * @returns {boolean} 是否成功处理
 */
function processHotelRow(row) {
    try {
        // 避免重复处理
        const existingTd = row.find('.self-td');
        if (existingTd.length > 0) {
            return false;
        }

        console.log("遍历新的表格行");

        // 提取信息
        const hotelNameDiv = row.find('div[name="divGoToHotelName"]');
        const hotelName = getHotelName(hotelNameDiv.contents().first().text().trim());

        // 安全检查：确保myMap已初始化并且是Map类型
        if (!myMap || !(myMap instanceof Map)) {
            console.warn('模板数据尚未加载完成，跳过处理酒店:', hotelName);
            const selfDiv = $(`<td class="self-td" style="position:absolute;height:108px;overflow:auto;border-bottom:none!important;cursor:pointer">模板加载中...</td>`);
            row.append(selfDiv);
            return false;
        }

        if (!hotelName || hotelName.trim() === '') {
            console.warn('未能获取酒店名称');
            createWarningCell(row, '未获取到酒店名称');
            return false;
        }

        if (!myMap.has(hotelName)) {
            // 创建并添加新的td元素
            const selfDiv = $(`<td class="self-td" style="position:absolute;height:108px;overflow:auto;border-bottom:none!important;cursor:pointer">无匹配酒店</td>`);
            row.append(selfDiv);
            console.log('未找到酒店模板:', hotelName);
            return false;
        }

        // 从行中提取各种信息 - 增加错误捕获
        let userName, targetElement, dateArr, startDate, endDate, roomTypeAstr, roomNumStr, roomNum, roomType, mealType, nightNumStr, nightNum, channelStr, channel;
        try {
            userName = row.find('td:nth-child(4) > div.occupant').text().replace("VIP", "");
            targetElement = row.find('td:nth-child(2) > div');
            dateArr = getDate(targetElement.text().trim());

            if (!dateArr || dateArr.length < 2) {
                createWarningCell(row, '日期信息无效');
                return false;
            }

            startDate = dateArr[0];
            endDate = dateArr[1];
            roomTypeAstr = row.find('a.d-blue').text();
            roomNumStr = row.find('td:nth-child(3) > .d-lightgray').text();
            roomNum = getRoomNum(roomNumStr);
            roomType = getRoomType(roomTypeAstr);
            mealType = getMealType(roomTypeAstr);
            nightNumStr = row.find('td:nth-child(2) > div > .d-lightgray').text();
            nightNum = getNightNum(nightNumStr);
            channelStr = row.find('.table-inline').text();
            channel = getChannel(channelStr);
        } catch (extractError) {
            console.error('提取酒店信息时出错:', extractError);
            createWarningCell(row, '提取信息出错');
            return false;
        }

        // 获取模板并格式化 - 增加错误捕获
        let result;
        try {
            const template = myMap.get(hotelName);
            const data = {
                hotelName,
                userName,
                roomType,
                mealType,
                startDate,
                endDate,
                roomNum,
                nightNum,
                channel
            };
            result = formatTemplate(template, data);
        } catch (formatError) {
            console.error(`格式化模板出错 (${hotelName}):`, formatError);
            createWarningCell(row, '格式化出错');
            return false;
        }

        // 创建并添加新的td元素 - 增加错误捕获
        try {
            const selfDiv = $(`<td class="self-td" style="position:absolute;height:108px;overflow:auto;border-bottom:none!important;cursor:pointer">${result}</td>`);
            row.append(selfDiv);

            // 添加双击复制功能
            selfDiv.on('dblclick', async function(e) {
                e.stopPropagation(); // 阻止冒泡
                try {
                    const htmlContent = $(this).html();
                    const content = processHtmlContent(htmlContent);
                    await copyToClipboard(content);
                } catch (copyError) {
                    console.error('复制到剪贴板失败:', copyError);
                    showMessage('复制失败');
                }
            });

            // 添加悬停效果
            selfDiv.hover(
                function() {
                    $(this).css('background-color', '#f0f0f0');
                },
                function() {
                    $(this).css('background-color', '');
                }
            );

            console.log(`成功处理酒店: ${hotelName}`);
            return true;
        } catch (domError) {
            console.error('创建或添加DOM元素时出错:', domError);
            return false;
        }
    } catch (error) {
        console.error('处理酒店行时发生未预期错误:', error);
        return false;
    }
}

/**
 * 创建警告提示单元格
 * @param {jQuery} row - 酒店行jQuery对象
 * @param {string} message - 警告消息
 */
function createWarningCell(row, message) {
    const selfDiv = $(`<td class="self-td" style="position:absolute;height:108px;overflow:auto;border-bottom:none!important;color:#856404;background-color:#fff3cd;font-size:11px;font-style:italic">⚠ ${message}</td>`);
    row.append(selfDiv);
}

/**
 * 为酒店行添加备注信息
 * @returns {number} 成功处理的酒店行数量
 */
function addRemark() {
    let processedCount = 0;
    try {
        const startTime = Date.now();
        const hotelRows = $('.hoteltr');

        if (hotelRows.length === 0) {
            console.log('未找到酒店行元素');
            return processedCount;
        }

        console.log(`找到${hotelRows.length}个酒店行元素，开始处理...`);

        hotelRows.each(function(index, row) {
            const $row = $(row);
            // 检查是否已处理过，避免重复处理
            if ($row.data('processed') === true) {
                return;
            }

            try {
                if (processHotelRow($row)) {
                    processedCount++;
                    $row.data('processed', true);
                }
            } catch (error) {
                const hotelName = $row.find('div[name="divGoToHotelName"]').contents().first().text().trim() || '未知';
                console.error(`处理酒店[${hotelName}]时出错:`, error);
            }
        });

        const endTime = Date.now();
        console.log(`处理完成，成功处理${processedCount}个酒店行，耗时${endTime - startTime}ms`);

        return processedCount;
    } catch (error) {
        console.error('执行addRemark函数时出错:', error);
        showMessage('处理酒店信息时发生错误');
        return processedCount;
    }
}

/**
 * 获取指定索引的酒店标题
 * @param {number} index - 酒店行索引
 * @returns {string|null} 格式化后的酒店标题
 */
function getTitle(index) {
    try {
        const row = $('.hoteltr')[index];
        if (!row) return null;

        // 安全检查：确保myMap已初始化并且是Map类型
        if (!myMap || !(myMap instanceof Map)) {
            console.warn('模板数据尚未加载完成');
            return null;
        }

        const hotelNameDiv = $(row).find('div[name="divGoToHotelName"]');
        const hotelName = getHotelName($(hotelNameDiv).contents().first().text().trim());

        if (!hotelName || !myMap.has(hotelName)) {
            return null;
        }

        const userName = $(row).find('td:nth-child(4) > div.occupant').text();
        const targetElement = $(row).find('td:nth-child(2) > div');
        const dateArr = getDate(targetElement.text().trim());

        if (!dateArr || dateArr.length < 2) {
            return null;
        }

        const startDate = dateArr[0];
        const endDate = dateArr[1];
        const roomTypeAstr = $(row).find('a.d-blue').text();
        const roomNumStr = $(row).find(' td:nth-child(3) > .d-lightgray').text();
        const roomNum = getRoomNum(roomNumStr);
        const roomType = getRoomType(roomTypeAstr);
        const mealType = getMealType(roomTypeAstr);
        const nightNum = getNightNum($(row).find('td:nth-child(2) > div > .d-lightgray').text());

        const template = myMap.get(hotelName);
        const data = {
            hotelName,
            userName,
            roomType,
            mealType,
            startDate,
            endDate,
            roomNum,
            nightNum
        };

        return formatTemplate(template, data);
    } catch (error) {
        console.error('获取标题错误:', error);
        return null;
    }
}

/**
 * 清理资源并停止轮询
 */
function cleanup() {
    if (intervalID) {
        clearInterval(intervalID);
        intervalID = null;
    }
}

// 页面加载完成后初始化
$(document).ready(async function() {
    console.log('页面加载完成，开始初始化脚本');
    // 创建提示框
    createMessageBox();

    // 显示初始化消息
    showMessage('脚本初始化中，正在加载模板数据...');

    try {
        // 异步初始化酒店模板
        await initializeHotelTemplates();
        console.log('模板初始化完成');
        showMessage('模板加载成功，开始处理酒店数据...');
    } catch (error) {
        console.error('初始化过程中发生错误:', error);
        showMessage('初始化失败，使用默认模板继续');
    }

    // 开始处理酒店数据
    startProcessing();

    // 页面卸载前清理资源
    window.addEventListener('beforeunload', cleanup);
});

/**
 * 开始处理酒店行数据，设置轮询间隔
 */
function startProcessing() {
    try {
        console.log('开始处理酒店行数据...');

        // 验证myMap是否已初始化
        if (!myMap || !(myMap instanceof Map)) {
            console.error('模板数据未初始化，无法开始处理');
            showMessage('模板数据未就绪，请刷新页面重试');
            return;
        }

        console.log(`当前模板数据包含${myMap.size}个酒店模板`);

        // 立即执行一次
        const initialCount = addRemark();

        if (initialCount > 0) {
            console.log(`首次处理完成，成功处理${initialCount}个酒店行`);
            showMessage(`已处理${initialCount}个酒店信息`);
        } else {
            console.log('首次处理未找到可处理的酒店行');
        }

        // 设置轮询间隔为1秒
        intervalID = setInterval(() => {
            const processedCount = addRemark();
            if (processedCount > 0) {
                console.log(`轮询处理完成，新增${processedCount}个酒店行`);
            }
        }, 1000);

        // 安全机制：5分钟后自动停止轮询，避免长时间运行
        setTimeout(() => {
            if (intervalID) {
                clearInterval(intervalID);
                intervalID = null;
                console.log('已自动停止轮询处理');
                showMessage('自动停止轮询，累计运行5分钟');
            }
        }, 5 * 60 * 1000); // 5分钟
    } catch (error) {
        console.error('启动处理过程时出错:', error);
        showMessage('启动处理失败，请刷新页面重试');
    }
}
